
/**
 * 获取节点
 * @param {文本|nw节点对象|其他-直接返回} JD 文本=主键；nw=JD.Jiedian；其他=return 其他；
 * @returns 原始节点对象
 */
NW01.prototype.hqJD = function (zhi) {
    if (typeof zhi == 'string') {
        return document.getElementById(zhi);
    }
    else if (zhi.Jiedian) {
        return zhi.Jiedian;
    } else {//传入的是普通的节点的对象
        return zhi;
    }
}



/**
 * 获取(hq)一个节点(Jiedian)内容（NeiRong) 对象里面的 内容(neiRong)
 * 
 * @参数 {对象} Jiedian 节点
 * @返回 {文本} 节点的【内容对象】的内容
 */
NW01.prototype.hqNR = function (Jiedian) {
    let _WB = this.hqNRjd(Jiedian);
    if (_WB) {
        return _WB.nodeValue;
    }
    return '';
}
/**
 * 获取(hq)一个节点(Jiedian)内容（NeiRong)
 * 
 * @参数 {id|dom/nw对象} Jiedian 节点
 * @返回 {对象} 节点的【内容对象】
 */
NW01.prototype.hqNRjd = function (Jiedian) {
    let _JD = this.hqJD(Jiedian);
    let _Erzim = _JD.childNodes; //取出所有的子节点。
    if (_Erzim.length == 0) { //没有子节点，
        return null; //返回null
    }
    //开始找 文本节点。
    for (let i = 0; i < _Erzim.length; i++) {
        if (_Erzim[i].nodeType == 3) { //找到文本节点。
            return _Erzim[i]; //返回 文本节点。
        }
    }
    //没有找到文本节点，返回null
    return null;
}
/**
 * 取节点的所有（包含它的所有下游 文本对象 ）文本对象 
 * @返回 {*} Jiedian 节点
 * @返回 {*} WenbenJiedianS 数组-存放 文本对象 的结果容器
 * @返回 {真|假} pdGuolvHHF 是否过滤 换行符号(HHF); true=过滤；false=不过滤
 */
NW01.prototype.hqNRjdM = function (Jiedian, _JG, pdGuolvHHF) {
    let _JD = this.hqJD(Jiedian);
    //取出所有的子节点
    let Erzim = _JD.childNodes;
    if (Erzim.length == 0) { //没有子节点，
        return null; //返回null
    }
    let _WB;
    //开始找 文本节点。
    for (let i = 0; i < Erzim.length; i++) {
        if (Erzim[i].nodeType == 3) { //找到文本节点。
            _WB = Erzim[i]; //返回 文本节点。
            if (_WB.nodeValue) {
                if (pdGuolvHHF) {
                    _WB.nodeValue = _WB.nodeValue.replace(/[\r\n]/g, "");
                }
                _JG.push(_WB);
            }
            continue;
        } else {
            this.hqNRjdM(Erzim[i], _JG, pdGuolvHHF);//递归
        }
    }
}

/**
 * 删除 (sc)一个节点(Jiedian)内容（NeiRong)
 * 
 * @参数 {对象} Jiedian 节点
 */
NW01.prototype.scNRjd = function (Jiedian) {
    let _WB = this.hqNRjd(Jiedian);
    if (_WB) {
        Jiedian.removeChild(_WB);
    }
}
/**
 * 判断父子关系
 * 如果两个节点是父子节点。那么,返回true。其情况情况，一键是false
 * @参数 {对象} father 父节点
 * @参数 {对象} son 子节点
 * @参数 {boolean} fuDengYuZi 是否父子节点相同（同个节点） true=允许；false=不允许 
 */
NW01.prototype.pdFuzi = function (Fu, Zi, fuDengYuZi) {
    if (!Fu || !Zi) {
        return false;
    }
    let _F = this.hqJD(Fu);
    let _Z = this.hqJD(Zi);
    if (fuDengYuZi && _F == _Z) {
        return true;
    }
    if (_F = _Z.parentNode) {
        return true;
    }
    return false; //找不到。证明不是row节点里面的节点。或不是单元格。
}
//------------↑↑↑↑↑【节点-父子关系】↑↑↑↑↑------------


/**
 * 判断Shang是否是Xia的上游.是返回true；否返回false
 * 
 * 如果Shang等于Xia，也返回true;
 * @参数 {对象} Shang 上游原始节点
 * @参数 {对象} Xia 下游原始节点
 * @参数 {真假} ShangDengYuXia 是否允许 上游等于下游
 * 
 * @返回 判断结果
 */
NW01.prototype.pdShangxiaYou = function (Shang, Xia, shangDengyuXia) {
    if (!Shang || !Xia) {
        return false;
    }
    let _S = this.hqJD(Shang);
    let _X = this.hqJD(Xia);
    if (!_S || !_X) {
        return false;
    }
    if (shangDengyuXia && _S == _X) {
        return true;
    }
    while (_X = _X.parentNode) {
        if (_X == _S) {
            return true;
        }
    }
    return false;
}

//------------↓↓↓↓↓【创建节点】↓↓↓↓↓------------
/**
 * 创建一个节点
 * @参数 {文本} bqMing 节点标签。如果没有指明标签符号，默认是 div
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW01.prototype.cjJiedian = function (bqMing, SXdx) {
    let _JD = document.createElement(bqMing ? bqMing : 'div');
    if (SXdx) {
        let _zhi;
        let _SX;
        for (let ming in SXdx) { 					//_ysYB：样式游标 的意思。
            _zhi = SXdx[ming];
            _SX = document.createAttribute(ming); 	//创建一个新的属性
            if (_zhi != null) {
                _SX.value = _zhi;					//设置属性值
            }
            _JD.setAttributeNode(_SX); 				//加入属性到节点里
        }
    }
    return _JD;
}

/**
 * 创建一个div节点
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW01.prototype.cjJiedian_div = function (SXdx) {
    return this.cjJiedian('div', SXdx);
}

/**
 * 创建一个a节点
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW01.prototype.cjJiedian_a = function (SXdx) {
    return this.cjJiedian('a', SXdx);
}

/**
 * 创建一个span节点
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW01.prototype.cjJiedian_span = function (SXdx) {
    return this.cjJiedian('span', SXdx);
}

/**
 * 创建一个input节点
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW01.prototype.cjJiedian_input = function (SXdx) {
    return this.cjJiedian('input', SXdx);
}

/**
 * 创建一个select节点
 * 
 * @参数 {数组} xxS 选项列表 对象 数组;  数组[{ming:'xxxxxx' ,zhi:'ssssss'}]
 * @参数 {对象} SXdx 属性列表 对象;
 * @返回 {对象} 节点对象
 */
NW01.prototype.cjJiedian_select = function (xxS, morenzhi, SXdx) {
    //创建一个选择节点
    let _JD = this.cjJiedian('select', SXdx);
    let _JDxx;
    if (xxS) {
        for (let i = 0; i < xxS.length; i++) {
            _JDxx = document.createElement("option");
            _JDxx.value = xxS[i].zhi;
            _JDxx.text = xxS[i].ming;
            if (morenzhi == xxS[i].zhi) {
                _JDxx.selected = true;
            }
            _JD.add(_JDxx);
        }
    }
    return _JD;
}
//------------↑↑↑↑↑【创建节点】↑↑↑↑↑------------

/**
 * 取 Jiedian 节点及其他下游所有节点的 【模板属性——即，属性值带着占位符的】 属性对象
 * @返回 {对象} Jiedian 节点
 * @返回 {数组} SXJiedianS 数组-存放 发展对象 的结果容器
 */
NW01.prototype.hqMBsxM = function (Jiedian, SXJiedianS) {
    let _ShuxingS = Jiedian.attributes;//节点的所有属性;
    //判断 所有的属性值，是否包括 模板符号。
    if (_ShuxingS) {
        for (let i = 0; i < _ShuxingS.length; i++) {
            if (_ShuxingS[i].value.indexOf("}") != -1) {	//如果此属性值包含模板符号
                SXJiedianS.push(_ShuxingS[i]);		//缓存属性
            }
        }
    }
    //取出所有的子节点
    let Erzim = Jiedian.children;
    if (Erzim.length == 0) { //没有子节点，
        return;
    }
    //取出每一个子节点的 所有属性
    for (let i = 0; i < Erzim.length; i++) {
        this.hqMBsxM(Erzim[i], SXJiedianS);//递归
    }
}

/**
 * 设置复选框状态
 * zhi== null         表示取反
 * zhi== false        表示全部不勾选
 * zhi== true         表示全部勾选
 * zhi=='1,2'         表示只对选框值为1、2的两个选框，设置zt状态。 其他 (!zt) 状态
 * 
 * @param {文本}        mc 节点名
 * @param {文本|数字}   zhi 
 * @param {真|假}       zt 
 */
NW01.prototype.szZT_fxk = function (mc, zhi, zt) {
    let jdm = typeof mc == 'string' ? document.getElementsByName(mc) : mc
    // zhi= null         表示取反
    if (zhi == null) {
        for (let i = 0; i < jdm.length; i++) {
            jdm[i].checked = !jdm[i].checked
        }
        return;
    }
    let _zjzhi = typeof zhi == 'boolean';
    //zhi=false 表示全部不勾选
    if (_zjzhi && !zhi) {
        this._ngj_szZT_fxk(jdm, false);
        return;
    }
    //zhi=true  表示全部勾选
    if (_zjzhi && zhi) {
        this._ngj_szZT_fxk(jdm, true);
        return;
    }
    zt = zt ? true : false;
    let zt2 = !zt;
    if (typeof zhi == 'number') {
        zhi += ''
    } else {
        zhi = NWHS_sck(zhi);
    }
    //全部取反状态
    this._ngj_szZT_fxk(jdm, zt2);
    // for (let j = 0; j < jdm.length; j++) {
    //     jdm[j].checked = zt2;
    // }
    //zhi='1' 
    if (zhi.indexOf(',') == -1) {
        for (let i = 0; i < jdm.length; i++) {
            if (jdm[i].value == zhi) {
                jdm[i].checked = zt
                return;
            }
        }
    }
    // zhi='1,2'
    let zhiM = zhi.split(',');
    for (let i = 0; i < zhiM.length; i++) {
        zhiM[i] = NWHS_sck(zhiM[i])//除空选
    }
    //符合值的，取zt状态
    for (let j = 0; j < jdm.length; j++) {
        zhi = NWHS_sck(jdm[j].value);//取节点的value值
        for (let i = 0; i < zhiM.length; i++) {
            if (zhi == zhiM[i]) {   //  判断 节点.value == 用户的值（切割出来的）
                jdm[j].checked = zt;
                break
            }
        }
    }
}

NW01.prototype._ngj_szZT_fxk = function (fxkM, zt) {
    for (let i = 0; i < fxkM.length; i++) {
        fxkM[i].checked = zt
    }
}

/**
 * 获取 xx状态的复选框的值
 * @param {文本} mc 节点名
 * @param {真假} zt 状态
 * @param {真假} szfzJG 返回的结果，是否以数组形式返回。真=数组形式 ['q','w','e'] ， 假=文本方式。'a,b,d,c'
 */
NW01.prototype.hqZT_fxk_dxk = function (mc, zt, szfzJG) {
    let jdm = typeof mc == 'string' ? document.getElementsByName(mc) : mc
    zt = zt ? true : false;

    let sz = szfzJG ? true : false;
    let jg = sz ? [] : '';

    for (let i = 0; i < jdm.length; i++) {
        if (jdm[i].checked == zt) {
            if (sz) {
                jg.push(jdm[i].value)
            } else {
                if (jg) {
                    jg += ','
                }
                jg += jdm[i].value;
            }
        }
    }
    return jg;
}


/**
 * 设置单选框状态
 * zhi== 假值||zt==假值        表示全部不勾选
 * zhi=='1'          表示只对选框值为1的两个选框，设置zt状态。 其他 (!zt) 状态
 * 
 * @param {文本}        mc 节点名
 * @param {文本|数字}   zhi 
 * @param {真|假}       zt 
 */
NW01.prototype.szZT_dxk = function (mc, zhi, zt) {
    let jdm = typeof mc == 'string' ? document.getElementsByName(mc) : mc
    zt = typeof zt == 'string' ? new Boolean(zt) : (zt ? true : false);
    // zhi== 假|null ||zt==假值        表示全部不勾选
    let zhilx = typeof zhi;
    if (null == zhi || (zhilx == 'boolean' && !zhi) || !zt) {
        this._ngj_szZT_fxk(jdm, false);
        return;
    }
    if (zhilx == 'number') {
        zhi += ''
    } else {
        zhi = NWHS_sck(zhi);
    }
    //zhi='1' 
    // console.log(zhi + '//' + zt)
    for (let i = 0; i < jdm.length; i++) {
        if (jdm[i].value == zhi) {
            jdm[i].checked = zt
            return;
        }
    }
}
